home *** CD-ROM | disk | FTP | other *** search
/ Nebula 1 / Nebula One.iso / Communications / pcomm / Source / p_lib.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-06-12  |  7.1 KB  |  291 lines
  1. /*
  2.  * Routines to manipulate the pcomm.param file.
  3.  */
  4.  
  5. #include <stdio.h>
  6. #include "param.h"
  7.  
  8. /*
  9.  * Read the parameter structure from the pcomm.param file.  Returns a
  10.  * pointer to a static area containing the PARAM structure.  All errors
  11.  * are fatal.
  12.  */
  13.  
  14. struct PARAM *
  15. read_param(extra)
  16. char *extra;
  17. {
  18.     FILE *fp, *my_fopen();
  19.     int i, line, oops;
  20.     char buf[200], *temp_token, *str, *str_dup(), *findfile();
  21.     char message[80], *str_tok();
  22.     static char *token[NUM_PARAM] = {"D_BAUD", "D_PARITY", "D_DBITS",
  23.     "D_SBITS", "HOT", "ASCII_HOT", "D_DUPLEX", "FLOW", "CR_IN", "CR_OUT",
  24.     "LOGFILE", "DUMPFILE", "STRIP", "PAUSE_CHAR", "CR_CHAR", "CTRL_CHAR",
  25.     "ESC_CHAR", "BRK_CHAR", "ABORT", "C_DELAY", "R_DELAY", "LECHO",
  26.     "EXPAND", "CR_DELAY", "PACE", "CR_UP", "LF_UP", "TIMER", "CR_DN",
  27.     "LF_DN", "LD_PLUS", "LD_MINUS", "LD_AT", "LD_POUND", "MAC_1",
  28.     "MAC_2", "MAC_3", "MAC_4", "MAC_5", "MAC_6", "MAC_7", "MAC_8",
  29.     "MAC_9", "MAC_0"};
  30.     static struct PARAM p;
  31.     void error_win();
  32.  
  33.     if ((p.p_path = findfile(extra, "pcomm.param")) == NULL)
  34.         error_win(1, "Support file \"pcomm.param\" is missing", "or no read permission");
  35.  
  36.     if (!(fp = my_fopen(p.p_path, "r"))) {
  37.         sprintf(buf, "\"%s\" for read", p.p_path);
  38.         error_win(1, "Can't open parameter file", buf);
  39.     }
  40.  
  41.     oops = 0;
  42.     line = 0;
  43.     for (i=0; i<NUM_PARAM; i++) {
  44.         line++;
  45.         if (fgets(buf, 200, fp) == NULL) {
  46.             sprintf(message, "is truncated at line %d", line);
  47.             oops++;
  48.             break;
  49.         }
  50.                     /* parse the input line */
  51.         if (!(temp_token = str_tok(buf, '='))) {
  52.             sprintf(message, "is missing a token at line %d", line);
  53.             oops++;
  54.             break;
  55.         }
  56.         if (!(str = str_tok((char *) NULL, '\n'))) {
  57.             sprintf(message, "is missing a parameter at line %d", line);
  58.             oops++;
  59.             break;
  60.         }
  61.                     /* sanity checking */
  62.         if (strcmp(temp_token, token[i])) {
  63.             sprintf(message, "is corrupted at line %d", line);
  64.             oops++;
  65.             break;
  66.         }
  67.  
  68.         switch (i) {
  69.                     /* used in ls_menu() */
  70.             case LINE_SET:
  71.                 p.d_baud = atoi(str);
  72.                 break;
  73.             case LINE_SET+1:
  74.                 p.d_parity = *str;
  75.                 break;
  76.             case LINE_SET+2:
  77.                 p.d_dbits = atoi(str);
  78.                 break;
  79.             case LINE_SET+3:
  80.                 p.d_sbits = atoi(str);
  81.                 break;
  82.  
  83.                     /* used in term_setup() */
  84.             case TERM_SETUP:
  85.                 p.hot = atoi(str);
  86.                 break;
  87.             case TERM_SETUP+1:
  88.                 p.ascii_hot = str_dup(str);
  89.                 break;
  90.             case TERM_SETUP+2:
  91.                 p.d_duplex = str_dup(str);
  92.                 break;
  93.             case TERM_SETUP+3:
  94.                 p.flow = str_dup(str);
  95.                 break;
  96.             case TERM_SETUP+4:
  97.                 p.cr_in = str_dup(str);
  98.                 break;
  99.             case TERM_SETUP+5:
  100.                 p.cr_out = str_dup(str);
  101.                 break;
  102.  
  103.                     /* used in gen_setup() */
  104.             case GEN_SETUP:
  105.                 p.logfile = str_dup(str);
  106.                 break;
  107.             case GEN_SETUP+1:
  108.                 p.dumpfile = str_dup(str);
  109.                 break;
  110.             case GEN_SETUP+2:
  111.                 p.strip = str_dup(str);
  112.                 break;
  113.             case GEN_SETUP+3:
  114.                 p.pause_char = *str;
  115.                 break;
  116.             case GEN_SETUP+4:
  117.                 p.cr_char = *str;
  118.                 break;
  119.             case GEN_SETUP+5:
  120.                 p.ctrl_char = *str;
  121.                 break;
  122.             case GEN_SETUP+6:
  123.                 p.esc_char = *str;
  124.                 break;
  125.             case GEN_SETUP+7:
  126.                 p.brk_char = *str;
  127.                 break;
  128.             case GEN_SETUP+8:
  129.                 p.abort = str_dup(str);
  130.                 break;
  131.  
  132.                     /* used in gen_setup() delay_times() */
  133.             case DELAY_TIMES:
  134.                 p.c_delay = atoi(str);
  135.                 break;
  136.             case DELAY_TIMES+1:
  137.                 p.r_delay = atoi(str);
  138.                 break;
  139.  
  140.                     /* used in axfer_setup() */
  141.             case ASCII_SETUP:
  142.                 p.lecho = str_dup(str);
  143.                 break;
  144.             case ASCII_SETUP+1:
  145.                 p.expand = str_dup(str);
  146.                 break;
  147.             case ASCII_SETUP+2:
  148.                 p.cr_delay = atoi(str);
  149.                 break;
  150.             case ASCII_SETUP+3:
  151.                 p.pace = str_dup(str);
  152.                 break;
  153.             case ASCII_SETUP+4:
  154.                 p.cr_up = str_dup(str);
  155.                 break;
  156.             case ASCII_SETUP+5:
  157.                 p.lf_up = str_dup(str);
  158.                 break;
  159.             case ASCII_SETUP+6:
  160.                 p.timer = atoi(str);
  161.                 break;
  162.             case ASCII_SETUP+7:
  163.                 p.cr_dn = str_dup(str);
  164.                 break;
  165.             case ASCII_SETUP+8:
  166.                 p.lf_dn = str_dup(str);
  167.                 break;
  168.  
  169.                     /* used in d_revise() */
  170.             case LD_CODES:
  171.                 p.ld_plus = str_dup(str);
  172.                 break;
  173.             case LD_CODES+1:
  174.                 p.ld_minus = str_dup(str);
  175.                 break;
  176.             case LD_CODES+2:
  177.                 p.ld_at = str_dup(str);
  178.                 break;
  179.             case LD_CODES+3:
  180.                 p.ld_pound = str_dup(str);
  181.                 break;
  182.  
  183.                     /* used in macro() */
  184.             case MACROS:
  185.                 p.mac_1 = str_dup(str);
  186.                 break;
  187.             case MACROS+1:
  188.                 p.mac_2 = str_dup(str);
  189.                 break;
  190.             case MACROS+2:
  191.                 p.mac_3 = str_dup(str);
  192.                 break;
  193.             case MACROS+3:
  194.                 p.mac_4 = str_dup(str);
  195.                 break;
  196.             case MACROS+4:
  197.                 p.mac_5 = str_dup(str);
  198.                 break;
  199.             case MACROS+5:
  200.                 p.mac_6 = str_dup(str);
  201.                 break;
  202.             case MACROS+6:
  203.                 p.mac_7 = str_dup(str);
  204.                 break;
  205.             case MACROS+7:
  206.                 p.mac_8 = str_dup(str);
  207.                 break;
  208.             case MACROS+8:
  209.                 p.mac_9 = str_dup(str);
  210.                 break;
  211.             case MACROS+9:
  212.                 p.mac_0 = str_dup(str);
  213.                 break;
  214.         }
  215.     }
  216.     fclose(fp);
  217.     if (oops) {
  218.         sprintf(buf, "Parameter file \"%s\"", p.p_path);
  219.         error_win(1, buf, message);
  220.     }
  221.     return(&p);
  222. }
  223.  
  224. /*
  225.  * Write the updated param structure to disk.  The values in memory should
  226.  * have already been "purified".  A non-zero return code means non-fatal
  227.  * error.
  228.  */
  229.  
  230. int
  231. up_param()
  232. {
  233.     FILE *fp, *my_fopen();
  234.     char buf[80];
  235.     void error_win();
  236.                     /* open for write */
  237.     if (!(fp = my_fopen(param->p_path, "w"))) {
  238.         sprintf(buf, "\"%s\"", param->p_path);
  239.         error_win(0, "No write permission on parameter file", buf);
  240.         return(1);
  241.     }
  242.  
  243.     fprintf(fp, "D_BAUD=%d\n", param->d_baud);
  244.     fprintf(fp, "D_PARITY=%c\n", param->d_parity);
  245.     fprintf(fp, "D_DBITS=%d\n", param->d_dbits);
  246.     fprintf(fp, "D_SBITS=%d\n", param->d_sbits);
  247.     fprintf(fp, "HOT=%d\n", param->hot);
  248.     fprintf(fp, "ASCII_HOT=%s\n", param->ascii_hot);
  249.     fprintf(fp, "D_DUPLEX=%s\n", param->d_duplex);
  250.     fprintf(fp, "FLOW=%s\n", param->flow);
  251.     fprintf(fp, "CR_IN=%s\n", param->cr_in);
  252.     fprintf(fp, "CR_OUT=%s\n", param->cr_out);
  253.     fprintf(fp, "LOGFILE=%s\n", param->logfile);
  254.     fprintf(fp, "DUMPFILE=%s\n", param->dumpfile);
  255.     fprintf(fp, "STRIP=%s\n", param->strip);
  256.     fprintf(fp, "PAUSE_CHAR=%c\n", param->pause_char);
  257.     fprintf(fp, "CR_CHAR=%c\n", param->cr_char);
  258.     fprintf(fp, "CTRL_CHAR=%c\n", param->ctrl_char);
  259.     fprintf(fp, "ESC_CHAR=%c\n", param->esc_char);
  260.     fprintf(fp, "BRK_CHAR=%c\n", param->brk_char);
  261.     fprintf(fp, "ABORT=%s\n", param->abort);
  262.     fprintf(fp, "C_DELAY=%d\n", param->c_delay);
  263.     fprintf(fp, "R_DELAY=%d\n", param->r_delay);
  264.     fprintf(fp, "LECHO=%s\n", param->lecho);
  265.     fprintf(fp, "EXPAND=%s\n", param->expand);
  266.     fprintf(fp, "CR_DELAY=%d\n", param->cr_delay);
  267.     fprintf(fp, "PACE=%s\n", param->pace);
  268.     fprintf(fp, "CR_UP=%s\n", param->cr_up);
  269.     fprintf(fp, "LF_UP=%s\n", param->lf_up);
  270.     fprintf(fp, "TIMER=%d\n", param->timer);
  271.     fprintf(fp, "CR_DN=%s\n", param->cr_dn);
  272.     fprintf(fp, "LF_DN=%s\n", param->lf_dn);
  273.     fprintf(fp, "LD_PLUS=%s\n", param->ld_plus);
  274.     fprintf(fp, "LD_MINUS=%s\n", param->ld_minus);
  275.     fprintf(fp, "LD_AT=%s\n", param->ld_at);
  276.     fprintf(fp, "LD_POUND=%s\n", param->ld_pound);
  277.     fprintf(fp, "MAC_1=%s\n", param->mac_1);
  278.     fprintf(fp, "MAC_2=%s\n", param->mac_2);
  279.     fprintf(fp, "MAC_3=%s\n", param->mac_3);
  280.     fprintf(fp, "MAC_4=%s\n", param->mac_4);
  281.     fprintf(fp, "MAC_5=%s\n", param->mac_5);
  282.     fprintf(fp, "MAC_6=%s\n", param->mac_6);
  283.     fprintf(fp, "MAC_7=%s\n", param->mac_7);
  284.     fprintf(fp, "MAC_8=%s\n", param->mac_8);
  285.     fprintf(fp, "MAC_9=%s\n", param->mac_9);
  286.     fprintf(fp, "MAC_0=%s\n", param->mac_0);
  287.  
  288.     fclose(fp);
  289.     return(0);
  290. }
  291.